import { defineStore } from 'pinia'
import { ref, markRaw } from 'vue'
import { asyncRoutes } from '@/router/asyncRoutes' // 导入异步路由
import menuApi from '@/api/menu' // 导入 menu API
import Layout from '@/layout/index.vue' // Layout 组件可能需要直接引用

// Helper function to check roles
function hasPermission(roles, route) {
  if (route.meta && route.meta.roles) {
    return roles.some(role => route.meta.roles.includes(role))
  } else {
    // If no roles are defined for the route, it's accessible by default
    return true 
  }
}

// Filter async routes based on roles
function filterAsyncRoutes(routes, roles) {
  const res = []
  routes.forEach(route => {
    const tmp = { ...route }
    if (hasPermission(roles, tmp)) {
      if (tmp.children) {
        tmp.children = filterAsyncRoutes(tmp.children, roles)
      }
      res.push(tmp)
    }
  })
  return res
}

// 创建一个查找 asyncRoutes 中组件的辅助函数或 Map
const routeMap = new Map();
function buildRouteMap(routes, parentPath = '') {
  routes.forEach(route => {
    // 注意：这里假设 asyncRoutes 里的 path 是相对于父级的，需要拼接
    // 如果 asyncRoutes 里的 path 已经是完整路径，则不需要 parentPath
    // 根据你的 asyncRoutes.js 结构调整
    const currentPath = route.path.startsWith('/') ? route.path : `${parentPath}/${route.path}`.replace(/\/\//g, '/');
    if (route.name) {
      routeMap.set(route.name, route); // 使用 name 作为 key
    }
    if (route.children) {
      buildRouteMap(route.children, currentPath);
    }
  });
}
// 预先构建映射，只需要执行一次
buildRouteMap(asyncRoutes);

// 递归构建可添加的路由 (根据后端菜单和前端路由配置)
function buildAddableRoutes(backendMenus) {
  const addableRoutes = [];
  if (!Array.isArray(backendMenus)) {
      console.error("后端菜单数据格式错误，期望是一个数组:", backendMenus);
      return [];
  }
  backendMenus.forEach(menu => {
    const frontendRoute = routeMap.get(menu.name); // 通过 name 查找前端路由配置

    let componentToUse = null;
    if (menu.component === 'Layout') {
        componentToUse = Layout;
    } else if (frontendRoute && frontendRoute.component) {
        componentToUse = frontendRoute.component;
    } else if (menu.component) {

        console.warn(`后端菜单项 '${menu.name}' 指定了组件 '${menu.component}'，但在前端 asyncRoutes 中未找到精确匹配的组件引用。将尝试使用 Layout 或跳过。`);
        // 如果找不到精确匹配，可以考虑默认用 Layout 或 null
        if (!componentToUse) componentToUse = null; // 或者 Layout，取决于你的设计
    }

    // 只有当能确定组件时才创建路由 (Layout 或从前端配置找到的组件)
    if (componentToUse) {
      const newRoute = {
        path: menu.path || (frontendRoute ? frontendRoute.path : '/' + menu.name.toLowerCase()), // 优先用后端的 path，否则尝试从前端或生成
        name: menu.name,
        component: markRaw(componentToUse),
        redirect: menu.redirect || (frontendRoute ? frontendRoute.redirect : undefined),
        meta: {
          // 合并 meta，后端 > 前端 > 默认
          ...(frontendRoute?.meta || {}),
          title: menu.title || (frontendRoute?.meta?.title) || menu.name || '未命名菜单', // 确保title始终有值
          icon: menu.icon || frontendRoute?.meta?.icon || '',
          hidden: menu.hidden ?? frontendRoute?.meta?.hidden ?? false,
          keepAlive: menu.keep_alive ?? frontendRoute?.meta?.keepAlive ?? false,
          isFrame: menu.is_frame ?? frontendRoute?.meta?.isFrame ?? false,
          // ... 其他你需要的 meta 属性
          requiresAuth: true // 动态路由通常都需要认证
        },
        // 递归处理子菜单
        children: menu.children && menu.children.length > 0
                  ? buildAddableRoutes(menu.children)
                  : (frontendRoute?.children ? [] : undefined) // 保持 children 结构，如果前端定义了但后端没有
      };
      addableRoutes.push(newRoute);
    } else if (menu.children && menu.children.length > 0) {
      
        const childRoutes = buildAddableRoutes(menu.children);
        addableRoutes.push(...childRoutes); // 将子路由直接添加到当前层级
    } else {
      console.warn(`后端菜单项 '${menu.name}' (路径: ${menu.path}) 无法找到对应的有效前端组件，将被忽略。`);
    }
  });
  return addableRoutes;
}

// 权限存储
export const usePermissionStore = defineStore('permission', () => {
  // 标记路由是否已初始化
  const hasInitRoutes = ref(false)
  // 存储用户可访问的动态路由
  const accessedRoutes = ref([])
  const backendMenuTree = ref([]) // 存储从后端获取的原始菜单树
  const isLoadingRoute = ref(false) // 新增：路由加载状态
  const loading = ref(false) // 加载状态

  // 设置路由初始化状态
  function setHasInitRoutes(status) {
    hasInitRoutes.value = status
  }

  // 获取角色权限列表
  async function getRolePermissions(roleId) {
    if (!roleId) {
      console.error('获取角色权限需要提供角色ID');
      return [];
    }
    
    try {
      loading.value = true;
  
      
      // 调用API获取角色权限
      const res = await menuApi.getRoleMenus(roleId);
    
      
      if (!res) {
        
        return [];
      }
      
      // 检查响应状态码
      if (res.code !== 200 && res.code !== 0) {
        console.error(`API请求返回错误码: ${res.code}`, res.message || res.msg);
        return [];
      }
      
      // 根据不同的数据结构尝试提取权限列表
      let permissions = [];
      
      if (res.data === null || res.data === undefined) {
        console.warn('API响应中没有data字段');
        return [];
      }
      
      // 处理各种可能的数据格式
      if (Array.isArray(res.data)) {
        // 直接是数组
        permissions = res.data;
      } else if (typeof res.data === 'object') {
        // 数据在子属性中
        if (Array.isArray(res.data.list)) {
          permissions = res.data.list;
        } else if (Array.isArray(res.data.permissions)) {
          permissions = res.data.permissions;
        } else if (Array.isArray(res.data.menus)) {
          permissions = res.data.menus;
        } else if (Array.isArray(res.data.menuList)) {
          permissions = res.data.menuList;
        } else if (Array.isArray(res.data.menuIds)) {
          permissions = res.data.menuIds;
        } else {
          // 最后尝试查找任何数组属性
          const arrayProps = Object.keys(res.data).find(key => Array.isArray(res.data[key]));
          if (arrayProps) {
            permissions = res.data[arrayProps];
          }
        }
      }
      
      // 如果permissions是对象数组，则尝试提取其中的菜单ID
      if (permissions.length > 0 && typeof permissions[0] === 'object') {
        if (permissions[0].id !== undefined) {
          permissions = permissions.map(item => item.id);
        } else if (permissions[0].menuId !== undefined) {
          permissions = permissions.map(item => item.menuId);
        } else if (permissions[0].key !== undefined) {
          permissions = permissions.map(item => item.key);
        } else if (permissions[0].name !== undefined) {
          permissions = permissions.map(item => item.name);
        }
      }
      
      console.log(`成功提取角色 ${roleId} 的权限:`, permissions);
      return permissions;
    } catch (error) {
      console.error(`获取角色 ${roleId} 权限出错:`, error);
      return [];
    } finally {
      loading.value = false;
    }
  }
  
  // 更新角色权限
  async function updateRolePermissions(roleId, permissions) {
    if (!roleId) {
      console.error('更新角色权限需要提供角色ID');
      return false;
    }
    
    try {
      loading.value = true;

      
      // 调用API更新角色权限
      const res = await menuApi.updateRoleMenus(roleId, permissions);
      
      if (res && (res.code === 200 || res.code === 0)) {
        console.log(`成功更新角色 ${roleId} 的权限`);
        return true;
      } else {
        console.error('更新角色权限失败:', res);
        return false;
      }
    } catch (error) {
      console.error(`更新角色 ${roleId} 权限出错:`, error);
      return false;
    } finally {
      loading.value = false;
    }
  }

  async function generateRoutes() { // 不再需要 roles 参数
    try {
  
      const res = await menuApi.getUserMenus(); // 调用 API 获取菜单


      // 检查返回结果是否符合预期格式
      if (res && (res.code === 200 || res.code === 0) && res.data && Array.isArray(res.data.list)) {
         backendMenuTree.value = res.data.list || []; // 存储后端原始数据
     

         const addable = buildAddableRoutes(backendMenuTree.value);
         accessedRoutes.value = addable; // 存储转换后可添加的路由
        

         return accessedRoutes.value; // 返回可添加的路由
      } else {
  
        backendMenuTree.value = [];
        accessedRoutes.value = [];
        return []; // 返回空数组表示失败
      }
    } catch (error) {
 
      backendMenuTree.value = [];
      accessedRoutes.value = [];
      return []; // 返回空数组表示失败
    }
  }

  // 重置路由状态
  function resetRoutes() {
    accessedRoutes.value = []
    backendMenuTree.value = []
    hasInitRoutes.value = false
    console.log("权限 store 已重置");
  }

  return {
    hasInitRoutes,
    accessedRoutes, // 导出可访问路由
    backendMenuTree, // 暴露给 Sidebar 使用
    setHasInitRoutes,
    generateRoutes, // 导出生成函数
    resetRoutes, // 导出重置函数
    isLoadingRoute,
    loading,
    getRolePermissions, // 导出获取角色权限函数
    updateRolePermissions // 导出更新角色权限函数
  }
}) 